<template>
  <ExamPaper :items="paper" :name="title" @update:answers="val => (finalAnswers = val)" />
</template>

<script setup>
import { ref, onMounted, computed } from 'vue'
import ExamPaper from '@/components/ExamPaper.vue'
// 使用路由meta中的name作为标题
import { useRoute } from 'vue-router'
const route = useRoute()
const title = computed(() => {
  return route.meta.title || '算法题库'
})

const paper = ref([
    {
        question:` 
        DP
        给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

        注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

        

        示例 1：

        输入: s = "leetcode", wordDict = ["leet", "code"]
        输出: true
        解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
        示例 2：

        输入: s = "applepenapple", wordDict = ["apple", "pen"]
        输出: true
        解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
            注意，你可以重复使用字典中的单词。
        示例 3：

        输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
        输出: false
        

        提示：

        1 <= s.length <= 300
        1 <= wordDict.length <= 1000
        1 <= wordDict[i].length <= 20
        s 和 wordDict[i] 仅由小写英文字母组成
        wordDict 中的所有字符串 互不相同
        `,
        answer:`
        function deal1(str, wordDict) {
            const map = new Map();
            wordDict.forEach((item) => {
                const startChart = item[0];
                map.has(startChart)
                ? map.get(startChart).push(item)
                : map.set(startChart, [item]);
            });
            let result = false;
            function step(str) {
                const startChart = str[0];
                const arr = map.get(startChart);
                if(!arr){
                return
                }
                for (let index = 0; index < arr.length; index++) {
                if (str.slice(0, arr[index].length) == arr[index]) {
                    let strOld = str;
                    str=str.slice(arr[index].length)
                    if(str == ''){
                    result = true
                    return
                    }
                    step(str)
                    str=strOld
                }
                }
            }
            step(str);
            console.log(result)
            return result
        }
        `,
        remark:`
        `
    },
    {
        question:`
        dp
        746. 使用最小花费爬楼梯
        简单
        相关标签
        premium lock icon
        相关企业
        提示
        给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

        你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

        请你计算并返回达到楼梯顶部的最低花费。

        

        示例 1：

        输入：cost = [10,15,20]
        输出：15
        解释：你将从下标为 1 的台阶开始。
        - 支付 15 ，向上爬两个台阶，到达楼梯顶部。
        总花费为 15 。
        示例 2：

        输入：cost = [1,100,1,1,1,100,1,1,100,1]
        输出：6
        解释：你将从下标为 0 的台阶开始。
        - 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
        - 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
        - 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
        - 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
        - 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
        - 支付 1 ，向上爬一个台阶，到达楼梯顶部。
        总花费为 6 。
        

        提示：

        2 <= cost.length <= 1000
        0 <= cost[i] <= 999
        `,
        answer:`
        function deal2(cost) {
            let result
            if(cost.length == 1){
                return cost[0]
            }else if(cost.length == 2){
                return Math.min(cost[0],cost[1]);
            }else{
                let pre1Total = 0;
                let pre1Num = cost[0];
                let pre2Total = 0;
                let pre2Num = cost[1]
                for (let index = 2; index <= cost.length; index++) {
                    const minCurrentStepTotal = Math.min(pre1Total+pre1Num,pre2Total+pre2Num);
                    if(index == cost.length){
                        result = minCurrentStepTotal
                    }
                    const currrentStepNum = cost[index];
                    pre1Total = pre2Total;
                    pre1Num = pre2Num;
                    pre2Total = minCurrentStepTotal;
                    pre2Num = currrentStepNum
                }
            }
            console.log(result)
            return result
        }
        `,
        remark:`
        `
    },
    {
        question:`
        dp
        70. 爬楼梯
        简单
        相关标签
        premium lock icon
        相关企业
        提示
        假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

        每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

        

        示例 1：

        输入：n = 2
        输出：2
        解释：有两种方法可以爬到楼顶。
        1. 1 阶 + 1 阶
        2. 2 阶
        示例 2：

        输入：n = 3
        输出：3
        解释：有三种方法可以爬到楼顶。
        1. 1 阶 + 1 阶 + 1 阶
        2. 1 阶 + 2 阶
        3. 2 阶 + 1 阶
        

        提示：

        1 <= n <= 45
        `,
        answer:`
        function deal3(n){
            let num = 0
            function step(n){
                if(n-1>0){
                    step(n-1)
                }else if (n-1 == 0){
                    num+=1
                    return
                }else{
                    return
                }

                if(n-2>0){
                    step(n-2)
                }else if (n-2 == 0){
                    num+=1
                    return
                }else{
                    return 
                }
            }
            step(n)
            console.log(num)
            return num
        }
        `,
        remark:`
        `
    },
    {
        question:`
        dp
        35. 搜索插入位置
        简单
        相关标签
        premium lock icon
        相关企业
        给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

        请必须使用时间复杂度为 O(log n) 的算法。

        

        示例 1:

        输入: nums = [1,3,5,6], target = 5
        输出: 2
        示例 2:

        输入: nums = [1,3,5,6], target = 2
        输出: 1
        示例 3:

        输入: nums = [1,3,5,6], target = 7
        输出: 4
        

        提示:

        1 <= nums.length <= 104
        -104 <= nums[i] <= 104
        nums 为 无重复元素 的 升序 排列数组
        -104 <= target <= 104
        `,
        answer:`
        function deal4(nums, target) {
            let result;
            function step(arr, start, end) {
                if (arr.length == 1) {
                if (target <= arr[0]) {
                    result = start;
                } else {
                    result = start + 1;
                }
                return;
                }
                const leftLength = Math.floor(arr.length / 2);
                const rightLength = Math.ceil(arr.length / 2);
                const leftArr = arr.slice(0, leftLength);
                const rightArr = arr.slice(leftLength);
                if (leftArr[leftLength - 1] == target) {
                    result = start + leftLength - 1;
                } else if (rightArr[0] == target) {
                    result = start + leftLength;
                } else if (target > leftArr[leftLength - 1] && target < rightArr[0]) {
                    result = start + leftLength;
                } else if (target < leftArr[leftLength - 1]) {
                    step(leftArr, start, leftLength - 1);
                } else if (target > rightArr[0]) {
                    step(rightArr, start + leftLength, end);
                }
            }
            step(nums, 0, target.length - 1);
            console.log(result);
            return result;
        }
        `,
        remark:`
        `
    },
])

onMounted(() => {
  
})

const finalAnswers = ref([])   // 实时收集到的答案
</script>